home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / msh-156.lha / han / hanconv.c < prev    next >
C/C++ Source or Header  |  1996-12-22  |  5KB  |  265 lines
  1. /*-
  2.  * $Id: hanconv.c,v 1.56 1996/12/22 00:22:33 Rhialto Rel $
  3.  * $Log: hanconv.c,v $
  4.  * Revision 1.56  1996/12/22  00:22:33  Rhialto
  5.  * Cosmetics only.
  6.  *
  7.  * Revision 1.55  1993/12/30  23:28:00    Rhialto
  8.  * Freeze for MAXON5.
  9.  *
  10.  * Revision 1.54  1993/06/24  05:12:49    Rhialto
  11.  * DICE 2.07.54R.
  12.  *
  13.  * Revision 1.53  92/10/25  02:41:38  Rhialto
  14.  * Rearrange initialisation of tables.
  15.  *
  16.  * Revision 1.51  92/04/17  15:38:09  Rhialto
  17.  * Freeze for MAXON.
  18.  *
  19.  * Revision 1.48  91/11/03  00:56:34  Rhialto
  20.  * Codes for s on PC/ST were swapped.
  21.  *
  22.  * Revision 1.46  91/10/06  18:24:51  Rhialto
  23.  *
  24.  * Freeze for MAXON
  25.  *
  26.  * Revision 1.45  91/10/03  23:34:41  Rhialto
  27.  * Initial version
  28.  *
  29.  *
  30.  * HANCONV.C
  31.  *
  32.  * The code for the messydos file system handler.
  33.  *
  34.  * This parts handles conversions on file data: PC/ST codes vs ISO-Latin-1.
  35.  *
  36.  * This code is (C) Copyright 1991-1993 by Olaf Seibert. All rights reserved.
  37.  * May not be used or copied without a licence.
  38. -*/
  39.  
  40. #include "han.h"
  41.  
  42. #if CONVERSIONS
  43. #include "hanconv.h"
  44.  
  45. #if HDEBUG
  46. #   include "syslog.h"
  47. #else
  48. #   define    debug(x)
  49. #endif
  50.  
  51. unsigned char  *InitTable(unsigned char *init);
  52.  
  53. void        rdwr_CopyMem(byte *from, byte *to, long fromsize);
  54. void        rd_FromPC(byte *from, byte *to, long fromsize);
  55. void        rd_FromST(byte *from, byte *to, long fromsize);
  56.  
  57. void        wr_ToPC(byte *from, byte *to, long fromsize);
  58. void        wr_ToST(byte *from, byte *to, long fromsize);
  59.  
  60. const ConversionFunc rd_Conv[] = {
  61.     rdwr_CopyMem, rd_FromPC, rd_FromST
  62. };
  63.  
  64. const ConversionFunc wr_Conv[] = {
  65.     rdwr_CopyMem, wr_ToPC, wr_ToST
  66. };
  67.  
  68. /*
  69.  * The conversion table pointers can be shared among multiple running
  70.  * instances of the handler, as long as we won't introduce user-defined
  71.  * conversion tables. Then we can do a copy-on-write.
  72.  * Must really protect against some race conditions with a shared semaphore.
  73.  */
  74.  
  75. Prototype short         ConversionImbeddedInFileName;
  76. Prototype short         DefaultConversion;
  77. Prototype __shared unsigned char *Table_ToPC;
  78. Prototype __shared unsigned char *Table_FromPC;
  79. Prototype __shared unsigned char *Table_ToST;
  80. Prototype __shared unsigned char *Table_FromST;
  81. Prototype void          ConvCleanUp(void);
  82.  
  83. short          ConversionImbeddedInFileName;
  84. short          DefaultConversion = ConvNone;
  85. __shared unsigned char *Table_ToPC;
  86. __shared unsigned char *Table_FromPC;
  87. __shared unsigned char *Table_ToST;
  88. __shared unsigned char *Table_FromST;
  89. void        ConvCleanUp(void);
  90.  
  91. unsigned char  *
  92. InitTable(init)
  93. unsigned char  *init;
  94. {
  95.     unsigned char  *table;
  96.  
  97.     if (table = AllocMem(256L, 0L)) {
  98.     int        i;
  99.  
  100.     for (i = 0; i < 256; i++)
  101.         table[i] = i;
  102.  
  103.     do {
  104.         i = *init++;
  105.         table[i] = *init++;
  106.     } while (i != 0);
  107.     }
  108.  
  109.     return table;
  110. }
  111.  
  112. void
  113. rdwr_CopyMem(from, to, fromsize)
  114. byte           *from;
  115. byte           *to;
  116. long        fromsize;
  117. {
  118.     CopyMem(from, to, fromsize);
  119. }
  120.  
  121. void
  122. rd_FromPC(from, to, fromsize)
  123. byte           *from;
  124. byte           *to;
  125. long        fromsize;
  126. {
  127.     static unsigned char init_FromPC[] = {
  128.     0x81, 0xFC,   /* u */
  129.     0x84, 0xE4,   /* a */
  130.     0x94, 0xF6,   /* o */
  131.     0x9A, 0xDC,   /* U */
  132.     0x8E, 0xC4,   /* A */
  133.     0x99, 0xD6,   /* O */
  134.     0xE1, 0xDF,   /* s */
  135.     0, 0
  136.     };
  137.  
  138.     Forbid();
  139.     if (Table_FromPC == 0)
  140.     Table_FromPC = InitTable(init_FromPC);
  141.     Permit();
  142.  
  143.     if (Table_FromPC != 0) {
  144.     unsigned char *table = Table_FromPC;
  145.  
  146.     for (; fromsize > 0; fromsize--, from++, to++)
  147.         *to = table[*from];
  148.     }
  149. }
  150.  
  151. void
  152. rd_FromST(from, to, fromsize)
  153. byte           *from;
  154. byte           *to;
  155. long        fromsize;
  156. {
  157.     static unsigned char init_FromST[] = {
  158.     0x81, 0xFC,   /* u */
  159.     0x84, 0xE4,   /* a */
  160.     0x94, 0xF6,   /* o */
  161.     0x9A, 0xDC,   /* U */
  162.     0x8E, 0xC4,   /* A */
  163.     0x99, 0xD6,   /* O */
  164.     0x9E, 0xDF,   /* s */
  165.     0, 0
  166.     };
  167.  
  168.     Forbid();
  169.     if (Table_FromST == 0)
  170.     Table_FromST = InitTable(init_FromST);
  171.     Permit();
  172.  
  173.     if (Table_FromST != 0) {
  174.     unsigned char *table = Table_FromST;
  175.  
  176.     for (; fromsize > 0; fromsize--, from++, to++)
  177.         *to = table[*from];
  178.     }
  179. }
  180.  
  181. void
  182. wr_ToPC(from, to, fromsize)
  183. byte           *from;
  184. byte           *to;
  185. long        fromsize;
  186. {
  187.     static unsigned char init_ToPC[] = {
  188.     0xFC, 0x81,   /* u */
  189.     0xE4, 0x84,   /* a */
  190.     0xF6, 0x94,   /* o */
  191.     0xDC, 0x9A,   /* U */
  192.     0xC4, 0x8E,   /* A */
  193.     0xD6, 0x99,   /* O */
  194.     0xDF, 0xE1,   /* s */
  195.     0, 0
  196.     };
  197.  
  198.     Forbid();
  199.     if (Table_ToPC == 0)
  200.     Table_ToPC = InitTable(init_ToPC);
  201.     Permit();
  202.  
  203.     if (Table_ToPC != 0) {
  204.     unsigned char *table = Table_ToPC;
  205.  
  206.     for (; fromsize > 0; fromsize--, from++, to++)
  207.         *to = table[*from];
  208.     }
  209. }
  210.  
  211. void
  212. wr_ToST(from, to, fromsize)
  213. byte           *from;
  214. byte           *to;
  215. long        fromsize;
  216. {
  217.     static unsigned char init_ToST[] = {
  218.     0xFC, 0x81,   /* u */
  219.     0xE4, 0x84,   /* a */
  220.     0xF6, 0x94,   /* o */
  221.     0xDC, 0x9A,   /* U */
  222.     0xC4, 0x8E,   /* A */
  223.     0xD6, 0x99,   /* O */
  224.     0xDF, 0x9E,   /* s */
  225.     0, 0
  226.     };
  227.  
  228.     Forbid();
  229.     if (Table_ToST == 0)
  230.     Table_ToST = InitTable(init_ToST);
  231.     Permit();
  232.  
  233.     if (Table_ToST != 0) {
  234.     unsigned char *table = Table_ToST;
  235.  
  236.     for (; fromsize > 0; fromsize--, from++, to++)
  237.         *to = table[*from];
  238.     }
  239. }
  240.  
  241. void
  242. ConvCleanUp()
  243. {
  244.     Forbid();
  245.     if (Table_FromPC) {
  246.     FreeMem(Table_FromPC, 256L);
  247.     Table_FromPC = 0;
  248.     }
  249.     if (Table_FromST) {
  250.     FreeMem(Table_FromST, 256L);
  251.     Table_FromST = 0;
  252.     }
  253.     if (Table_ToPC) {
  254.     FreeMem(Table_ToPC, 256L);
  255.     Table_ToPC = 0;
  256.     }
  257.     if (Table_ToST) {
  258.     FreeMem(Table_ToST, 256L);
  259.     Table_ToST = 0;
  260.     }
  261.     Permit();
  262. }
  263.  
  264. #endif /* CONVERSIONS */
  265.